home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Programming / vahunz / source / ugly / umemory.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-04-17  |  7.8 KB  |  485 lines
  1. /*
  2.  * This source file is part of Vahunz,
  3.  * a tool to make source code un-/more legible.
  4.  *
  5.  *--------------------------------------------------------------------------
  6.  *
  7.  * Vahunz and the Ugly library are Copyright (C) 1998 by
  8.  * Thomas Aglassinger <agi@giga.or.at>
  9.  *
  10.  * All rights reserved.
  11.  *
  12.  * Refer to the manual for more information.
  13.  *
  14.  *--------------------------------------------------------------------------
  15.  *
  16.  * Ubiqx library is Copyright (C) 1991-1998 by
  17.  * Christopher R. Hertel <crh@ubiqx.mn.org>
  18.  *
  19.  * Ubiqx library is free software; you can redistribute it and/or
  20.  * modify it under the terms of the GNU Library General Public
  21.  * License as published by the Free Software Foundation; either
  22.  * version 2 of the License, or (at your option) any later version.
  23.  *
  24.  */
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include "utypes.h"
  29. #define w5W
  30. #include "umemory.h"
  31. #define j7R 16
  32. #if defined(AMIGA)
  33. #define e0F 8 
  34. #else
  35. #define e0F 8
  36. #endif
  37. #ifndef a8L
  38. #define a8L(x,by) ((by)*(((x)+(by-1))/(by)))
  39. #endif
  40. static j6V *q1N = NULL;
  41. static UBYTE g4N[4] =
  42. {0xDE, 0xAD, 0xBE, 0xEF}; 
  43. static UBYTE v2S[4] =
  44. {0xDE, 0xAD, 0xF0, 0x0D}; 
  45. static UBYTE x6O = 0x81;
  46. static ULONG x0M = 0; 
  47. static ULONG i9S = 0; 
  48. static ULONG b3N = 0; 
  49. static ULONG u2N = 0; 
  50. static ULONG e5Z = 0; 
  51. static ULONG z6F = 0; 
  52. static ULONG d9S = 0; 
  53. static ULONG e8U = 0; 
  54. static ULONG g5A = 0; 
  55. static ULONG a1V = 0; 
  56. void *p6U(size_t c8H);
  57. static BOOL r3Z(j6V * r9D);
  58. BOOL(*i5X) (size_t c8H) = NULL;
  59. VOID s5F(char *msg, char *e9R, size_t p8T)
  60. {
  61. fprintf(stderr, "\n\n");
  62. fprintf(stderr, "  I won't be a monkey in anyone's zoo\n");
  63. fprintf(stderr, "  I won't get fazed whatever you do\n");
  64. fprintf(stderr, "                   (Ride, \"Not Fazed\")\n\n");
  65. fprintf(stderr, "** internal error: \"%s\" (%lu): %s\n", \
  66. e9R, (unsigned long) p8T, msg);
  67. exit(255);
  68. }
  69. static j6V *n5M(void *mem)
  70. {
  71. j6V *t8N = q1N;
  72. j6V *r5W = NULL;
  73. while (t8N && (!r5W))
  74. {
  75. if (t8N->ptr == mem)
  76. {
  77. r5W = t8N;
  78. }
  79. t8N = t8N->k0Z;
  80. }
  81. #if v2E==2
  82. if (!r5W)
  83. {
  84. fprintf(stderr, "*memory* FIND_UMEM: couln't find %p\n", mem);
  85. }
  86. #endif
  87. return (r5W);
  88. }
  89. static j6V *j8V(j6V * r9D)
  90. {
  91. j6V *prev = q1N;
  92. j6V *g1U = NULL;
  93. BOOL r5W = FALSE;
  94. while (prev && (!r5W))
  95. {
  96. r5W = (prev == r9D);
  97. if (!r5W)
  98. {
  99. g1U = prev;
  100. prev = prev->k0Z;
  101. }
  102. }
  103. return (g1U);
  104. }
  105. static void n6A(void *mem, size_t c8H, UBYTE value[4])
  106. {
  107. size_t i;
  108. for (i = 0; i < c8H; i++)
  109. {
  110. (((UBYTE *) mem)[i]) = value[i % 4];
  111. }
  112. }
  113. static void o0G(void *mem, size_t c8H, UBYTE value)
  114. {
  115. size_t i;
  116. for (i = 0; i < c8H; i++)
  117. {
  118. (((UBYTE *) mem)[i]) = value;
  119. }
  120. }
  121. static void m2K(j6V * r9D)
  122. {
  123. j6V *prev = j8V(r9D);
  124. if (prev)
  125. {
  126. prev->k0Z = r9D->k0Z;
  127. }
  128. else
  129. {
  130. q1N = r9D->k0Z;
  131. }
  132. if (!r3Z(r9D))
  133. {
  134. n6A(r9D->t5L, r9D->c8H + 2 * j7R, g4N);
  135. free(r9D->t5L);
  136. }
  137. r9D->t5L = NULL;
  138. r9D->s9E = NULL;
  139. r9D->c8H = 0;
  140. r9D->e9R = NULL;
  141. r9D->p8T = 0;
  142. free(r9D);
  143. }
  144. static j6V *a3W(size_t f5P, STRPTR l8V, ULONG o8G)
  145. {
  146. j6V *g8O = (j6V *) malloc(sizeof(j6V));
  147. if (g8O)
  148. {
  149. g8O->t5L = (UBYTE *) p6U(f5P
  150. + 2 * j7R);
  151. if (g8O->t5L)
  152. {
  153. g8O->ptr = (void *) (g8O->t5L + j7R);
  154. g8O->s9E = (g8O->t5L + j7R + f5P);
  155. g8O->k0Z = q1N;
  156. q1N = g8O;
  157. g8O->c8H = f5P;
  158. g8O->e9R = l8V;
  159. g8O->p8T = o8G;
  160. g8O->c2O = x6O;
  161. n6A(g8O->ptr, f5P, v2S);
  162. o0G(g8O->t5L, j7R, x6O);
  163. o0G(g8O->s9E, j7R, x6O);
  164. if (x6O == 0xff)
  165. {
  166. x6O = 0x81;
  167. }
  168. else
  169. {
  170. x6O++;
  171. }
  172. }
  173. else
  174. free(g8O);
  175. }
  176. return (g8O);
  177. }
  178. static void a3L(STRPTR msg)
  179. {
  180. fprintf(stderr, "%s\n", msg);
  181. }
  182. static void p2H(void *ptr, size_t c8H)
  183. {
  184. unsigned char *data = (unsigned char *) ptr;
  185. if (c8H > 16)
  186. {
  187. c8H = 16;
  188. }
  189. fprintf(stderr, "  %p:", ptr);
  190. if (data)
  191. {
  192. size_t i;
  193. for (i = 0; i < c8H; i++)
  194. {
  195. if (!(i % 4))
  196. {
  197. fprintf(stderr, " ");
  198. }
  199. fprintf(stderr, "%02x", data[i]);
  200. }
  201. while (i < 16)
  202. {
  203. if (!(i % 4))
  204. {
  205. fprintf(stderr, " ");
  206. }
  207. fprintf(stderr, "  ");
  208. i++;
  209. }
  210. fprintf(stderr, "  \"");
  211. for (i = 0; i < c8H; i++)
  212. {
  213. if (data[i] < ' ' || ((data[i] > 128) && (data[i] < 160)))
  214. {
  215. fprintf(stderr, ".");
  216. }
  217. else
  218. {
  219. fprintf(stderr, "%c", data[i]);
  220. }
  221. }
  222. fprintf(stderr, "\"\n");
  223. }
  224. else
  225. fprintf(stderr, "NULL\n");
  226. }
  227. static void k5G(void *ptr, STRPTR e9R, ULONG p8T)
  228. {
  229. fprintf(stderr, "  %p: from \"%s\" (%lu)\n", ptr, e9R, p8T);
  230. }
  231. static void o7U(j6V * r9D)
  232. {
  233. fprintf(stderr, "  %p: %lu (0x%lx) bytes from \"%s\" (%lu)\n",
  234. r9D->ptr, (ULONG) r9D->c8H, (ULONG) r9D->c8H,
  235. r9D->e9R, r9D->p8T);
  236. }
  237. static STRPTR l3J(UBYTE i7B)
  238. {
  239. static d6X r0E[30];
  240. UBYTE ch = i7B;
  241. if (ch < 32)
  242. ch = '.';
  243. sprintf(r0E, "(0x%02x/#%d/`%c')", i7B, i7B, ch);
  244. return (r0E);
  245. }
  246. static BOOL r3Z(j6V * r9D)
  247. {
  248. size_t i = 0;
  249. BOOL n3P = FALSE;
  250. while (!n3P && (i < j7R))
  251. {
  252. BOOL g9H = (r9D->t5L[i] != r9D->c2O);
  253. BOOL q1Cj = (r9D->s9E[i] != r9D->c2O);
  254. n3P = g9H || q1Cj;
  255. if (n3P)
  256. {
  257. STRPTR g1M;
  258. UBYTE value;
  259. if (g9H)
  260. {
  261. g1M = "LOWER";
  262. value = r9D->t5L[i];
  263. }
  264. else
  265. {
  266. g1M = "UPPER";
  267. value = r9D->s9E[i];
  268. }
  269. fprintf(stderr, "*** MEMORY WALL DAMAGED!!!\n");
  270. fprintf(stderr, "*** %s wall, byte#%lu is %s instead of 0x%02x\n",
  271. g1M, (ULONG) i, l3J(value), r9D->c2O);
  272. o7U(r9D);
  273. p2H(r9D->ptr, r9D->c8H);
  274. fprintf(stderr, "  * lower wall:\n");
  275. p2H(r9D->t5L, j7R);
  276. fprintf(stderr, "  * upper wall:\n");
  277. p2H(r9D->s9E, j7R);
  278. }
  279. else
  280. {
  281. i++;
  282. }
  283. }
  284. return (n3P);
  285. }
  286. VOID p4No(STRPTR msg, STRPTR e9R, ULONG p8T)
  287. {
  288. j6V *r9D = q1N;
  289. if (r9D)
  290. {
  291. fprintf(stderr, "MEMORY WALL-CHECK (%s)", msg);
  292. if (e9R)
  293. fprintf(stderr, " from `%s' (%lu)", e9R, p8T);
  294. fprintf(stderr, "\n");
  295. while (r9D)
  296. {
  297. if (r9D->ptr)
  298. {
  299. r3Z(r9D);
  300. r9D = r9D->k0Z;
  301. }
  302. else
  303. {
  304. r9D = NULL;
  305. fprintf(stderr, "\n** PANIC: memory list trashed\n");
  306. }
  307. }
  308. }
  309. }
  310. void r9C(STRPTR msg, STRPTR e9R, ULONG p8T, STRPTR date, STRPTR time)
  311. {
  312. j6V *r9D = q1N;
  313. if (r9D)
  314. {
  315. fprintf(stderr, "MEMORY REPORT (%s)\n", msg);
  316. if (e9R)
  317. {
  318. fprintf(stderr, "(\"%s\" (%lu), at %s, %s)\n",
  319. e9R, p8T, date, time);
  320. }
  321. while (r9D)
  322. {
  323. if (r9D->ptr)
  324. {
  325. o7U(r9D);
  326. p2H(r9D->ptr, r9D->c8H);
  327. r9D = r9D->k0Z;
  328. }
  329. else
  330. {
  331. r9D = NULL;
  332. fprintf(stderr, "##\n## panic: memory list trashed\n##\n");
  333. }
  334. }
  335. }
  336. }
  337. void a9M(STRPTR msg, STRPTR e9R, ULONG p8T, STRPTR date, STRPTR time)
  338. {
  339. fprintf(stderr, "MEMORY STATISTICS (%s)\n", msg);
  340. if (e9R)
  341. {
  342. fprintf(stderr, "(\"%s\" (%lu), at %s, %s)\n",
  343. e9R, p8T, date, time);
  344. }
  345. fprintf(stderr, "  bytes used: %lu max: %lu/%lu  ",
  346. z6F, d9S,
  347. e5Z);
  348. if (e5Z)
  349. {
  350. fprintf(stderr, "slack: %lu%%\n",
  351. (100 * (d9S - e5Z))
  352. / e5Z);
  353. }
  354. else
  355. {
  356. fprintf(stderr, "no slack\n");
  357. }
  358. fprintf(stderr, "  nodes used: %lu (max: %lu)\n",
  359. a1V, g5A);
  360. fprintf(stderr, "  calls to: umalloc(%lu)   ufree(%lu)\n",
  361. x0M, i9S);
  362. }
  363. void i0G(void)
  364. {
  365. ULONG f0A = z6F;
  366. r9C("at exit:  MEMORY LEAK detected!",
  367. NULL, 0, NULL, NULL);
  368. a9M("[exit]", NULL, 0, NULL, NULL);
  369. while (q1N)
  370. {
  371. m2K(q1N);
  372. }
  373. if (f0A)
  374. {
  375. fprintf(stderr, "\n%lu bytes of memory lost!\n", f0A);
  376. }
  377. }
  378. void d7G(void)
  379. {
  380. }
  381. void *p6U(size_t c8H)
  382. {
  383. void *mem;
  384. BOOL o8R;
  385. do
  386. {
  387. mem = malloc(c8H);
  388. if (!mem && i5X)
  389. {
  390. o8R = (*i5X) (c8H);
  391. if (!o8R)
  392. {
  393. exit(EXIT_FAILURE); 
  394. }
  395. }
  396. else
  397. {
  398. o8R = FALSE;
  399. }
  400. }
  401. while (o8R);
  402. return (mem);
  403. }
  404. void *e3L(size_t c8H, STRPTR e9R, ULONG p8T)
  405. {
  406. void *mem = NULL;
  407. j6V *r9D = NULL;
  408. #if v2E==2
  409. fprintf(stderr, "*memory* UMALLOC() from `%s' (%lu)\n", e9R, p8T);
  410. #endif
  411. if (c8H)
  412. {
  413. x0M++;
  414. r9D = a3W(c8H, e9R, p8T);
  415. if (r9D)
  416. {
  417. mem = r9D->ptr;
  418. z6F += c8H;
  419. e8U += a8L(c8H, e0F);
  420. if (z6F > e5Z)
  421. e5Z = z6F;
  422. if (e8U > d9S)
  423. d9S = e8U;
  424. a1V++;
  425. if (a1V > g5A)
  426. g5A = a1V;
  427. }
  428. }
  429. else
  430. {
  431. b3N++;
  432. a3L("MALLOC: zero-sized allocation");
  433. k5G(NULL, e9R, p8T);
  434. }
  435. return (mem);
  436. }
  437. void t2B(void *ptr, STRPTR e9R, ULONG p8T)
  438. {
  439. #if v2E==2
  440. fprintf(stderr, "*memory* UFREE() from `%s' (%lu)\n", e9R, p8T);
  441. #elif 0
  442. fputc('.', stderr); 
  443. fflush(stderr);
  444. #endif
  445. if (ptr)
  446. {
  447. j6V *r9D = n5M(ptr);
  448. if (r9D)
  449. {
  450. i9S++;
  451. z6F -= r9D->c8H;
  452. e8U -= a8L(r9D->c8H, e0F);
  453. m2K(r9D);
  454. a1V--;
  455. }
  456. else
  457. {
  458. u2N++;
  459. a3L("*** FREE: memory never allocated "
  460. " or released twice");
  461. k5G(ptr, e9R, p8T);
  462. }
  463. }
  464. }
  465. void *r4A(void *ptr, size_t c8H, STRPTR e9R, ULONG p8T)
  466. {
  467. void *h3Y = e3L(c8H, e9R, p8T);
  468. j6V *r9D = n5M(ptr);
  469. if (h3Y && r9D)
  470. {
  471. memcpy(h3Y, r9D->ptr, r9D->c8H);
  472. t2B(ptr, e9R, p8T);
  473. }
  474. return (h3Y);
  475. }
  476. void *f7L(size_t count, size_t c8H, STRPTR e9R, ULONG p8T)
  477. {
  478. void *mem = e3L(count * c8H, e9R, p8T);
  479. if (mem)
  480. {
  481. memset(mem, 0, c8H * count);
  482. }
  483. return (mem);
  484. }
  485.